package com.ruoyi.system.service.impl.video;

import java.util.ArrayList;
import java.util.List;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.config.VsAreaCode;
import com.ruoyi.system.domain.video.VsDramasCategory;
import com.ruoyi.system.domain.video.VsLangInit;
import com.ruoyi.system.domain.video.VsLangTranslate;
import com.ruoyi.system.mapper.video.VsDramasCategoryMapper;
import com.ruoyi.system.mapper.video.VsLangInitMapper;
import com.ruoyi.system.mapper.video.VsLangTranslateMapper;
import com.ruoyi.system.service.config.IVsAreaCodeService;
import com.ruoyi.system.service.video.IVsLangTranslateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.video.VsLangMapper;
import com.ruoyi.system.domain.video.VsLang;
import com.ruoyi.system.service.video.IVsLangService;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * 语言包Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-04-17
 */
@Service
public class VsLangServiceImpl implements IVsLangService 
{
    @Autowired
    private VsLangMapper vsLangMapper;
    @Autowired
    private VsDramasCategoryServiceImpl categoryMapper;

    @Autowired
    private VsLangInitMapper vsLangInitMapper;

    @Autowired
    private IVsLangTranslateService vsLangTranslateService;

    @Autowired
    private IVsAreaCodeService vsAreaCodeService;

    /**
     * 查询语言包
     * 
     * @param id 语言包主键
     * @return 语言包
     */
    @Override
    public VsLang selectVsLangById(String id)
    {
        return vsLangMapper.selectVsLangById(id);
    }

    /**
     * 查询语言包列表
     * 
     * @param vsLang 语言包
     * @return 语言包
     */
    @Override
    public List<VsLang> selectVsLangList(VsLang vsLang)
    {
        return vsLangMapper.selectVsLangList(vsLang);
    }

    /**
     * 新增语言包
     * 
     * @param vsLang 语言包
     * @return 结果
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    @Override
    public int insertVsLang(VsLang vsLang)
    {
        // 输入验证
        if (vsLang == null || StringUtils.isBlank(vsLang.getLang()) || StringUtils.isBlank(vsLang.getLangCn())) {
            throw new IllegalArgumentException("语言包参数无效");
        }
        return addInfo(vsLang);
    }

    private int addInfo(VsLang vsLang) {
        try {
            // 先查询表中是否有当前要新增的语言
            VsLang isLang = new VsLang();
            isLang.setLang(vsLang.getLang());
            List<VsLang> isLangList = vsLangMapper.getVsLangList(isLang);
            if (!isLangList.isEmpty()) {
                throw new IllegalArgumentException("语言包已存在");
            }
            // 把要新增的语言插入到库中
            int addLangCount = vsLangMapper.insertVsLang(vsLang);
            VsAreaCode areaCode = new VsAreaCode();
            areaCode.setLangId(65L);
            List<VsAreaCode> areaCodeList = vsAreaCodeService.selectVsAreaCodeList(areaCode);
            if (!areaCodeList.isEmpty()) {
                for (VsAreaCode a : areaCodeList) {
                    a.setLangId(Long.valueOf(vsLang.getId()));
                    a.setNameLang("");
                }
                vsAreaCodeService.translateAreaCode(areaCodeList);
            }
            // 先查询出目前所有的语言，后面需要把所有的语言及对应翻译放入到新增的语言中去
            List<VsLang> langList = vsLangMapper.getVsLangList(new VsLang());
            if (langList.isEmpty()) {
                throw new IllegalArgumentException("语言包列表为空");
            }
            // 如果初始化中没有相匹配的键值，就把新增的语言添加到语言初始化列表中
            int addInitCount = 0;
            VsLangInit init = new VsLangInit();
            init.setKeyCode(vsLang.getLang());
            List<VsLangInit> isInit = vsLangInitMapper.selectVsLangInitList(init);
            if (isInit.isEmpty()) {
                init.setChinese(vsLang.getLangCn());
                addInitCount = vsLangInitMapper.insertVsLangInit(init);
            }
            // 创建要翻译的对象及list
            // 把新增的语言放入到其他语言表中
            List<VsLangTranslate> translates = new ArrayList<>();
            int langTranslate = 0;
            for (VsLang v : langList) {
                // 只添加其他对应语言，本体不需要重复添加
                // 因为新增语言的时候直接就加在初始化里了，初始化翻译完后会直接返回来
                if (!v.getLang().equals(vsLang.getLang())) {
                    List<VsLangTranslate> translateList = new ArrayList<>();
                    VsLangTranslate translate = new VsLangTranslate();
                    translate.setKeyCode(vsLang.getLang());
                    translate.setChinese(vsLang.getLangCn());
                    translate.setLangId(Integer.valueOf(v.getId()));
                    translateList.add(translate);
                    translateList.get(0).setLanguageType(v.getLang());
                    translates = vsLangTranslateService.batchTranslate(translateList);
                    // 如果翻译失败就代表键值对不上或者不支持翻译该语言，直接返回空的language，让用户自己手动翻译
                    langTranslate = vsLangTranslateService.batchInsertVsLangTranslate(translates);
                }
            }
            // 因为初始化中可能有相同的键值，所以不做下面的判断
            if (addLangCount == 0 || langTranslate == 0) {
                throw new IllegalArgumentException("新增失败");
            }
            // 查出来初始化中所有的数据并添加到新增语言中
            List<VsLangInit> initList = vsLangInitMapper.selectVsLangInitList(new VsLangInit());
            for (VsLangInit i : initList) {
                // 如果语言列表中没有当前新增的语言就查看初始化模板里有没有当前语言
                if (i.getKeyCode().equals(vsLang.getLang()) && !i.getChinese().equals(vsLang.getLangCn())) {
                    VsLangInit vsLangInit = new VsLangInit();
                    vsLangInit.setKeyCode(vsLang.getLang());
                    vsLangInit.setChinese(vsLang.getLangCn());
                    vsLangInitMapper.updateVsLangInitByParams(vsLangInit);
                    i.setKeyCode(vsLang.getLang());
                    i.setChinese(vsLang.getLangCn());
                }
            }
            List<VsLangTranslate> insertList = new ArrayList<>();
            for (VsLangInit i : initList) {
                VsLangTranslate t = new VsLangTranslate();
                t.setLangId(Integer.valueOf(vsLang.getId()));
                t.setKeyCode(i.getKeyCode());
                t.setChinese(i.getChinese());
                insertList.add(t);
            }
            if (!insertList.isEmpty()) {
                vsLangTranslateService.batchInsertVsLangTranslate(insertList);
            }
            // 返回更新的记录总数
            return addInitCount + addLangCount + langTranslate;
        } catch (Exception e) {
            // 异常处理：记录日志并抛出异常，便于上层处理
            // 假设这里使用了一个日志库，如Log4j、SLF4J等
            // Logger.error("更新语言包失败", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改语言包
     * 
     * @param vsLang 语言包
     * @return 结果
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    @Override
    public int updateVsLang(VsLang vsLang) throws IllegalArgumentException {
        // 输入验证
        if (vsLang == null || StringUtils.isBlank(vsLang.getLang()) || StringUtils.isBlank(vsLang.getLangCn())) {
            throw new IllegalArgumentException("语言包参数无效");
        }
        return editInfo(vsLang);
    }

    private int editInfo(VsLang vsLang) {
        try {
            // 如果是修改就需要先修改原来语言的值再去查询取出来处理其他语言对应的值
            int updatedLangCount = vsLangMapper.updateVsLang(vsLang);
            // 先查询出目前所有的语言，后面需要把修改的语言及对应翻译放入到对应语言中去
            List<VsLang> langList = vsLangMapper.selectVsLangList(new VsLang());
            if (langList.isEmpty()) {
                throw new IllegalArgumentException("语言包列表为空");
            }
            // 先修改对应语言初始化数据
            VsLangInit init = new VsLangInit();
            init.setKeyCode(vsLang.getLang());
            init.setChinese(vsLang.getLangCn());
            int updatedInitCount = vsLangInitMapper.updateVsLangInitByParams(init);
            // 首先查出来语言包中关联的键值是否存在
            List<VsLangTranslate> translateList = new ArrayList<>();
            // 把修改的语言放入到其他语言中
            for (VsLang v : langList) {
                VsLangTranslate translate = new VsLangTranslate();
                translate.setKeyCode(vsLang.getLang());
                translate.setChinese(vsLang.getLangCn());
                translate.setLangId(Integer.valueOf(v.getId()));
                translateList.add(translate);
            }
            int langTranslate = vsLangTranslateService.batchInsertVsLangTranslate(translateList);
            // 返回更新的记录总数
            return updatedInitCount + updatedLangCount + langTranslate;
        } catch (Exception e) {
            // 异常处理：记录日志并抛出异常，便于上层处理
            // 假设这里使用了一个日志库，如Log4j、SLF4J等
            // Logger.error("更新语言包失败", e);
            throw new RuntimeException("更新语言包失败", e);
        }
    }

    /**
     * 批量删除语言包
     * 
     * @param ids 需要删除的语言包主键
     * @return 结果
     */
    @Override
    public int deleteVsLangByIds(String[] ids)
    {
        return vsLangMapper.deleteVsLangByIds(ids);
    }

    /**
     * 删除语言包信息
     * 
     * @param id 语言包主键
     * @return 结果
     */
    @Override
    public int deleteVsLangById(String id)
    {
        return vsLangMapper.deleteVsLangById(id);
    }

    @Override
    public List<VsLang> selectHomeCategorys(VsLang vsLang) {
        List<VsLang> list = vsLangMapper.selectVsLangList(vsLang);
        for (VsLang v: list) {
            VsDramasCategory category = new VsDramasCategory();
            category.setLangId(Long.valueOf(v.getId()));
            List<VsDramasCategory> categories = categoryMapper.selectHomeVideos(category);
            v.setCategories(categories);
        }
        return list;
    }

    @Override
    public List<VsLang> getVsLangList(VsLang vsLang) {
        return vsLangMapper.getVsLangList(vsLang);
    }
}
